{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = False\n",
    "equation_component_combination = [1.0,5.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = loadmat('data.mat')['uxy_list'][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = loadmat('data.mat')['uxy_list'][-1] + np.random.normal(loc=0.0, scale=0.1, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation_data = []\n",
    "\n",
    "theta_list = np.linspace(0,np.pi*2,800)\n",
    "for theta in theta_list:\n",
    "    x = x_theta(theta)\n",
    "    y = y_theta(theta)\n",
    "    comb = [1,0,0]\n",
    "    v = U(x,y)\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_2_loss', 'lambda_14_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:  443.28088 | domain_loss: 44271.01953 | bdc_loss:    0.57648\n",
      "epoch:  200.00000 | total_loss:   29.49990 | domain_loss: 2899.77954 | bdc_loss:    0.50717\n",
      "epoch:  400.00000 | total_loss:    7.27437 | domain_loss:  682.83105 | bdc_loss:    0.45056\n",
      "epoch:  600.00000 | total_loss:    3.30469 | domain_loss:  290.40671 | bdc_loss:    0.40467\n",
      "epoch:  800.00000 | total_loss:    1.89514 | domain_loss:  153.17627 | bdc_loss:    0.36705\n",
      "epoch: 1000.00000 | total_loss:    1.24574 | domain_loss:   91.31266 | bdc_loss:    0.33598\n",
      "epoch: 1200.00000 | total_loss:    0.90078 | domain_loss:   59.35622 | bdc_loss:    0.31032\n",
      "epoch: 1400.00000 | total_loss:    0.69537 | domain_loss:   40.90086 | bdc_loss:    0.28925\n",
      "epoch: 1600.00000 | total_loss:    0.56116 | domain_loss:   29.17397 | bdc_loss:    0.27214\n",
      "epoch: 1800.00000 | total_loss:    0.46783 | domain_loss:   21.19783 | bdc_loss:    0.25844\n",
      "epoch: 2000.00000 | total_loss:    0.40079 | domain_loss:   15.56007 | bdc_loss:    0.24767\n",
      "epoch: 2200.00000 | total_loss:    0.35215 | domain_loss:   11.51473 | bdc_loss:    0.23939\n",
      "epoch: 2400.00000 | total_loss:    0.31699 | domain_loss:    8.61108 | bdc_loss:    0.23321\n",
      "epoch: 2600.00000 | total_loss:    0.29184 | domain_loss:    6.53990 | bdc_loss:    0.22872\n",
      "epoch: 2800.00000 | total_loss:    0.27404 | domain_loss:    5.07084 | bdc_loss:    0.22559\n",
      "epoch: 3000.00000 | total_loss:    0.26152 | domain_loss:    4.02750 | bdc_loss:    0.22348\n",
      "epoch: 3200.00000 | total_loss:    0.25266 | domain_loss:    3.27662 | bdc_loss:    0.22212\n",
      "epoch: 3400.00000 | total_loss:    0.24627 | domain_loss:    2.72151 | bdc_loss:    0.22126\n",
      "epoch: 3600.00000 | total_loss:    0.24149 | domain_loss:    2.29576 | bdc_loss:    0.22074\n",
      "epoch: 3800.00000 | total_loss:    0.23778 | domain_loss:    1.95610 | bdc_loss:    0.22042\n",
      "epoch: 4000.00000 | total_loss:    0.23477 | domain_loss:    1.67569 | bdc_loss:    0.22022\n",
      "epoch: 4200.00000 | total_loss:    0.23225 | domain_loss:    1.43823 | bdc_loss:    0.22007\n",
      "epoch: 4400.00000 | total_loss:    0.23009 | domain_loss:    1.23382 | bdc_loss:    0.21996\n",
      "epoch: 4600.00000 | total_loss:    0.22821 | domain_loss:    1.05612 | bdc_loss:    0.21985\n",
      "epoch: 4800.00000 | total_loss:    0.22657 | domain_loss:    0.90086 | bdc_loss:    0.21975\n",
      "epoch: 5000.00000 | total_loss:    0.22511 | domain_loss:    0.76501 | bdc_loss:    0.21966\n",
      "epoch: 5200.00000 | total_loss:    0.22383 | domain_loss:    0.64620 | bdc_loss:    0.21956\n",
      "epoch: 5400.00000 | total_loss:    0.22269 | domain_loss:    0.54257 | bdc_loss:    0.21946\n",
      "epoch: 5600.00000 | total_loss:    0.22169 | domain_loss:    0.45256 | bdc_loss:    0.21936\n",
      "epoch: 5800.00000 | total_loss:    0.22082 | domain_loss:    0.37484 | bdc_loss:    0.21926\n",
      "epoch: 6000.00000 | total_loss:    0.22004 | domain_loss:    0.30819 | bdc_loss:    0.21915\n",
      "epoch: 6200.00000 | total_loss:    0.21937 | domain_loss:    0.25151 | bdc_loss:    0.21904\n",
      "epoch: 6400.00000 | total_loss:    0.21878 | domain_loss:    0.20377 | bdc_loss:    0.21893\n",
      "epoch: 6600.00000 | total_loss:    0.21826 | domain_loss:    0.16387 | bdc_loss:    0.21881\n",
      "epoch: 6800.00000 | total_loss:    0.21781 | domain_loss:    0.13098 | bdc_loss:    0.21868\n",
      "epoch: 7000.00000 | total_loss:    0.21741 | domain_loss:    0.10417 | bdc_loss:    0.21855\n",
      "epoch: 7200.00000 | total_loss:    0.21706 | domain_loss:    0.08278 | bdc_loss:    0.21841\n",
      "epoch: 7400.00000 | total_loss:    0.21674 | domain_loss:    0.06563 | bdc_loss:    0.21827\n",
      "epoch: 7600.00000 | total_loss:    0.21645 | domain_loss:    0.05245 | bdc_loss:    0.21811\n",
      "epoch: 7800.00000 | total_loss:    0.21619 | domain_loss:    0.04226 | bdc_loss:    0.21795\n",
      "epoch: 8000.00000 | total_loss:    0.21595 | domain_loss:    0.03532 | bdc_loss:    0.21777\n",
      "epoch: 8200.00000 | total_loss:    0.21570 | domain_loss:    0.02941 | bdc_loss:    0.21758\n",
      "epoch: 8400.00000 | total_loss:    0.21547 | domain_loss:    0.02636 | bdc_loss:    0.21738\n",
      "epoch: 8600.00000 | total_loss:    0.21523 | domain_loss:    0.02344 | bdc_loss:    0.21717\n",
      "epoch: 8800.00000 | total_loss:    0.21498 | domain_loss:    0.02196 | bdc_loss:    0.21693\n",
      "epoch: 9000.00000 | total_loss:    0.21472 | domain_loss:    0.02119 | bdc_loss:    0.21668\n",
      "epoch: 9200.00000 | total_loss:    0.21445 | domain_loss:    0.02174 | bdc_loss:    0.21640\n",
      "epoch: 9400.00000 | total_loss:    0.21414 | domain_loss:    0.02082 | bdc_loss:    0.21609\n",
      "epoch: 9600.00000 | total_loss:    0.21381 | domain_loss:    0.02095 | bdc_loss:    0.21575\n",
      "epoch: 9800.00000 | total_loss:    0.21344 | domain_loss:    0.02141 | bdc_loss:    0.21538\n",
      "epoch: 10000.00000 | total_loss:    0.21302 | domain_loss:    0.02126 | bdc_loss:    0.21495\n",
      "epoch: 10200.00000 | total_loss:    0.21255 | domain_loss:    0.02239 | bdc_loss:    0.21448\n",
      "epoch: 10400.00000 | total_loss:    0.21201 | domain_loss:    0.02168 | bdc_loss:    0.21393\n",
      "epoch: 10600.00000 | total_loss:    0.21140 | domain_loss:    0.02215 | bdc_loss:    0.21331\n",
      "epoch: 10800.00000 | total_loss:    0.21069 | domain_loss:    0.02284 | bdc_loss:    0.21259\n",
      "epoch: 11000.00000 | total_loss:    0.20986 | domain_loss:    0.02202 | bdc_loss:    0.21176\n",
      "epoch: 11200.00000 | total_loss:    0.20889 | domain_loss:    0.02205 | bdc_loss:    0.21078\n",
      "epoch: 11400.00000 | total_loss:    0.20775 | domain_loss:    0.02282 | bdc_loss:    0.20962\n",
      "epoch: 11600.00000 | total_loss:    0.20645 | domain_loss:    0.03005 | bdc_loss:    0.20823\n",
      "epoch: 11800.00000 | total_loss:    0.20473 | domain_loss:    0.02314 | bdc_loss:    0.20657\n",
      "epoch: 12000.00000 | total_loss:    0.20275 | domain_loss:    0.02430 | bdc_loss:    0.20455\n",
      "epoch: 12200.00000 | total_loss:    0.20027 | domain_loss:    0.01981 | bdc_loss:    0.20209\n",
      "epoch: 12400.00000 | total_loss:    0.19728 | domain_loss:    0.01749 | bdc_loss:    0.19909\n",
      "epoch: 12600.00000 | total_loss:    0.19362 | domain_loss:    0.01685 | bdc_loss:    0.19541\n",
      "epoch: 12800.00000 | total_loss:    0.18912 | domain_loss:    0.01301 | bdc_loss:    0.19090\n",
      "epoch: 13000.00000 | total_loss:    0.18365 | domain_loss:    0.01161 | bdc_loss:    0.18539\n",
      "epoch: 13200.00000 | total_loss:    0.17698 | domain_loss:    0.00977 | bdc_loss:    0.17867\n",
      "epoch: 13400.00000 | total_loss:    0.16891 | domain_loss:    0.00730 | bdc_loss:    0.17054\n",
      "epoch: 13600.00000 | total_loss:    0.15939 | domain_loss:    0.00822 | bdc_loss:    0.16092\n",
      "epoch: 13800.00000 | total_loss:    0.14832 | domain_loss:    0.01066 | bdc_loss:    0.14971\n",
      "epoch: 14000.00000 | total_loss:    0.13563 | domain_loss:    0.00385 | bdc_loss:    0.13696\n",
      "epoch: 14200.00000 | total_loss:    0.12176 | domain_loss:    0.00306 | bdc_loss:    0.12295\n",
      "epoch: 14400.00000 | total_loss:    0.10703 | domain_loss:    0.00293 | bdc_loss:    0.10808\n",
      "epoch: 14600.00000 | total_loss:    0.09197 | domain_loss:    0.00853 | bdc_loss:    0.09281\n",
      "epoch: 14800.00000 | total_loss:    0.07722 | domain_loss:    0.01288 | bdc_loss:    0.07787\n",
      "epoch: 15000.00000 | total_loss:    0.06327 | domain_loss:    0.00562 | bdc_loss:    0.06385\n",
      "epoch: 15200.00000 | total_loss:    0.05079 | domain_loss:    0.00387 | bdc_loss:    0.05126\n",
      "epoch: 15400.00000 | total_loss:    0.04017 | domain_loss:    0.00982 | bdc_loss:    0.04048\n",
      "epoch: 15600.00000 | total_loss:    0.03148 | domain_loss:    0.01216 | bdc_loss:    0.03167\n",
      "epoch: 15800.00000 | total_loss:    0.02469 | domain_loss:    0.01853 | bdc_loss:    0.02476\n",
      "epoch: 16000.00000 | total_loss:    0.01937 | domain_loss:    0.00028 | bdc_loss:    0.01956\n",
      "epoch: 16200.00000 | total_loss:    0.01567 | domain_loss:    0.00040 | bdc_loss:    0.01583\n",
      "epoch: 16400.00000 | total_loss:    0.01308 | domain_loss:    0.00042 | bdc_loss:    0.01321\n",
      "epoch: 16600.00000 | total_loss:    0.01134 | domain_loss:    0.00128 | bdc_loss:    0.01145\n",
      "epoch: 16800.00000 | total_loss:    0.01025 | domain_loss:    0.00691 | bdc_loss:    0.01028\n",
      "epoch: 17000.00000 | total_loss:    0.00955 | domain_loss:    0.01245 | bdc_loss:    0.00952\n",
      "epoch: 17200.00000 | total_loss:    0.00894 | domain_loss:    0.00005 | bdc_loss:    0.00903\n",
      "epoch: 17400.00000 | total_loss:    0.00861 | domain_loss:    0.00008 | bdc_loss:    0.00870\n",
      "epoch: 17600.00000 | total_loss:    0.00840 | domain_loss:    0.00053 | bdc_loss:    0.00848\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.00824 | domain_loss:    0.00006 | bdc_loss:    0.00832\n",
      "epoch: 18000.00000 | total_loss:    0.00818 | domain_loss:    0.00558 | bdc_loss:    0.00820\n",
      "epoch: 18200.00000 | total_loss:    0.00803 | domain_loss:    0.00017 | bdc_loss:    0.00811\n",
      "epoch: 18400.00000 | total_loss:    0.00796 | domain_loss:    0.00015 | bdc_loss:    0.00804\n",
      "epoch: 18600.00000 | total_loss:    0.00791 | domain_loss:    0.00070 | bdc_loss:    0.00798\n",
      "epoch: 18800.00000 | total_loss:    0.00786 | domain_loss:    0.00004 | bdc_loss:    0.00794\n",
      "epoch: 19000.00000 | total_loss:    0.00783 | domain_loss:    0.00122 | bdc_loss:    0.00790\n",
      "epoch: 19200.00000 | total_loss:    0.00779 | domain_loss:    0.00073 | bdc_loss:    0.00786\n",
      "epoch: 19400.00000 | total_loss:    0.00777 | domain_loss:    0.00150 | bdc_loss:    0.00783\n",
      "epoch: 19600.00000 | total_loss:    0.00773 | domain_loss:    0.00003 | bdc_loss:    0.00781\n",
      "epoch: 19800.00000 | total_loss:    0.00771 | domain_loss:    0.00003 | bdc_loss:    0.00779\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0002), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.007785554731578036"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean((uxy[0,:,:,0]-truth_data)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth_smooth':np.asarray(truth_smooth),\n",
    "                     'truth_data':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0)}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
